A bluffer's guide to Shader Models

Taking in the Vista

The future of PC graphics will be based, partly, on the next evolution of Windows. Called Windows Vista, it's scheduled to arrive in 2006. It sports a next-generation user interface, codenamed Aero, which will also be made available for Windows XP.

The neat thing about Aero is that it uses 3D hardware to render the desktop, allowing for sophisticated graphics effects. Consequently, DirectX 9 level hardware will be a requirement for getting the most out of standard Windows use in the next generation.

Currently, Windows applications redraw the screen themselves. If a part of the screen needs updating, the application simply draws over the top of it and outputs that new image to the graphics card for display on the screen. Windows has no memory of what was previously on screen before it was redrawn.

Aero uses the 3D hardware to layer redraws on top of each other off-screen. This method of drawing the screen makes it possible to achieve composition effects that were horrendously slow previously. For example, transparency can be achieved by blending redraw layers, so that the windows behind show through. Windows can fade in and out by changing this transparency. Windows can be manipulated as 3D objects and tiled, moved or rendered in different ways from those we have now. The composition is done in hardware because graphics hardware spends all its time in games compositing scenes in this manner, and so is very fast and efficient at doing so.

Markup

Understanding something about how applications are written for Windows can also show us the benefits brought to Longhorn by 3D hardware. User interfaces in the new OS can be written in markup; that is, defined through a series of simple statements in code. By using the hardware to layer the individual elements of a user interface on top of one another, individual buttons or dialogue boxes within an application can all have their own rendering effects applied individually.

Arriving with Longhorn, we suspect, Windows Graphics Foundation will bring about some changes as to how shaders and the entire 3D architecture is handled in Windows. WGF is the next major release of DirectX.

Over the course of the evolution from 2.0, 2.x and 3.0 of the pixel and vertex shader models, the abilities of pixel and vertex shaders have become very similar - originally, pixel shaders lacked the same functionality and complexity as vertex shaders. Carrying on this trend, all the WGF shader models are identical, and this identical specification makes the unification of pixel and vertex pipelines possible in hardware.

Shader unification in WGF

This unification allows a couple of other fringe benefits. Texuring, a pixel shader function, can be done inside the vertex shader, and this makes displacement map operations - where a pixel-based texture is extruded to give vertex-based height - quicker, because data doesn't have to be sent back and forth between the texture and vertex units.

New functions for dealing with integer numbers also make new hardware configurations possible, although not required. Currently, the only type of memory addressing that can be done between the GPU and its memory is a texture lookup, which uses a floating point values. By introducing integers into memory lookups, more precision is gained, enabling more flexibility in storing graphics data in places such as virtual memory or main system memory.

Using virtual video memory, addressed with these new integer functions - in the same way that a processor uses virtual memory today - allows for shaders of unlimited instruction length in theory, doing away with the maximum instruction length, because the only limit on how big a shader can be will be the limit on the virtual space allotted for the graphics memory. This should make for even more amazing graphical features and for extra speed. Currently, long shader routines have to be broken up into routines that will fit inside the shader length as specified. By having just one long shader, rather than lots of shorter ones, there is less performance overhead and more code simplicity, resulting in better performance.